Course: Python Training
Topic: Understanding Local, Global, and Nonlocal Scope
Course Link: Python Training Course at JustAcademy
Demo Link: Register for a Course Demo
Website: Visit JustAcademy
Scope in Python refers to the region of a program where a variable, function, or name can be accessed. Understanding scope helps programmers control how data is stored, accessed, and modified throughout an application.
Python uses the LEGB rule to determine where a name is searched for when it is referenced. LEGB stands for Local, Enclosing, Global, and Built-in scope.
print(), len(), and sum().Local, global, and nonlocal scope are especially important when working with functions, nested functions, callbacks, and reusable code.
global keyword.nonlocal keyword.A variable is a name that refers to an object in Python. The object may be a number, string, list, dictionary, function, or another data type.
name = "Aarav"
age = 22
course = "Python"
print(name)
print(age)
print(course)Output:
Aarav
22
PythonWhere a variable is defined influences where its name can be accessed. This is known as its scope.
A local variable is a name assigned inside a function. It is generally available only within that function's local scope.
def greet():
message = "Hello, Python!"
print(message)
greet()Output:
Hello, Python!In this example, message is a local variable because it is assigned inside greet().
A local variable normally cannot be accessed directly outside the function in which it is defined.
def show_number():
number = 100
print(number)
show_number()
# This raises NameError because number is local:
# print(number)Output:
100The function can access number, but the surrounding code cannot access that local name after the function call. Returning the value is one way to make the result available outside the function.
def get_number():
number = 100
return number
result = get_number()
print(result)Output:
100Two functions can use the same local variable name without sharing the variable binding. Each function has its own local scope.
def function_one():
value = 10
print("Function one:", value)
def function_two():
value = 50
print("Function two:", value)
function_one()
function_two()Output:
Function one: 10
Function two: 50The two variables named value are local to different functions, so assigning one does not change the other.
Function parameters are local names within the function unless other scope rules apply to a different name.
def calculate_square(number):
result = number * number
return result
print(calculate_square(6))Output:
36Both number and result are local names in calculate_square().
A global variable is a name defined at the module level, outside functions and classes. It can be accessed from functions in the same module, provided it is not shadowed by a local binding.
course_name = "Python Programming"
def display_course():
print(course_name)
display_course()
print(course_name)Output:
Python Programming
Python ProgrammingThe name course_name is defined at the module level. The function reads the global value because it does not create a local variable with the same name.
A function can read a global variable without using the global keyword, as long as the function does not assign to that name locally.
tax_rate = 0.18
def calculate_tax(amount):
return amount * tax_rate
print(calculate_tax(1000))Output:
180.0The function reads the global variable tax_rate and uses it to calculate the tax.
If a function assigns to a name, Python generally treats that name as local throughout the function unless the name is declared with global or nonlocal. A local name can therefore shadow a global name.
message = "Global message"
def display_message():
message = "Local message"
print(message)
display_message()
print(message)Output:
Local message
Global messageThe assignment inside display_message() creates a local binding. It does not modify the global variable.
The global keyword tells Python that a name used in a function refers to the module-level binding rather than a new local binding. It is useful when a function must reassign a global variable.
counter = 0
def increment():
global counter
counter += 1
increment()
increment()
increment()
print(counter)Output:
3Without global counter, the augmented assignment would treat counter as a local name and raise an error because its local value would be read before being assigned.
balance = 5000
def deposit(amount):
global balance
balance += amount
deposit(1500)
print(balance)Output:
6500The function modifies the module-level balance binding. For larger applications, passing the balance into a function and returning the updated value is often easier to test and maintain.
You do not need the global keyword merely to read a global variable. You need it when assigning to that global name from within a function.
total = 100
def show_total():
print(total) # Reading the global name
def update_total():
global total
total = 200
show_total()
update_total()
show_total()Output:
100
200The global keyword is not required merely to mutate an existing global list or dictionary, because the name is not being rebound.
students = ["Aarav", "Meera"]
def add_student(name):
students.append(name)
add_student("Kabir")
print(students)Output:
['Aarav', 'Meera', 'Kabir']However, assigning a new list to students inside the function would require a global students declaration if the intention were to rebind the module-level name.
Enclosing scope exists when one function is defined inside another function. The inner function can access names from its enclosing function, provided those names are available in the enclosing scope.
def outer_function():
message = "Hello from the outer function"
def inner_function():
print(message)
inner_function()
outer_function()Output:
Hello from the outer functionThe name message is local to outer_function(), but it is in the enclosing scope of inner_function().
def outer():
language = "Python"
def inner():
print("Learning:", language)
inner()
outer()Output:
Learning: PythonThe inner function reads the variable defined by the outer function. No nonlocal declaration is necessary because the inner function does not reassign the name.
The nonlocal keyword allows a nested function to reassign a name in the nearest enclosing function scope where that name already exists. It does not refer to the module-level global scope.
def outer():
count = 0
def inner():
nonlocal count
count += 1
inner()
inner()
print(count)
outer()Output:
2The nonlocal count declaration makes the assignment update the enclosing function's count binding.
def create_counter():
count = 0
def increment():
nonlocal count
count += 1
return count
return increment
counter = create_counter()
print(counter())
print(counter())
print(counter())Output:
1
2
3The inner function remembers the enclosing variable between calls. This pattern is known as a closure and can be used to maintain private state.
If a nested function assigns to a name, Python normally treats that name as local to the nested function. Reading it before the local assignment can produce an UnboundLocalError.
def outer():
value = 10
def inner():
# Python treats value as local because of the assignment.
# This causes UnboundLocalError:
# print(value)
# value = 20
pass
inner()
outer()To reassign the enclosing function's variable, declare it using nonlocal value inside the nested function.
The nonlocal keyword requires a binding in an enclosing function scope. It cannot be used to modify a module-level variable directly.
message = "Global"
def outer():
message = "Enclosing"
def inner():
nonlocal message
message = "Updated enclosing"
inner()
print(message)
outer()
print(message)Output:
Updated enclosing
GlobalThe inner function changes the enclosing variable. The module-level message remains unchanged.
Python follows the LEGB rule when resolving names. It searches the following scopes in order:
name = "Global"
def outer():
name = "Enclosing"
def inner():
name = "Local"
print(name)
inner()
outer()
print(name)Output:
Local
GlobalThe inner function prints its local value because local scope is searched before enclosing and global scope. The final statement prints the module-level value.
language = "Java"
def outer():
language = "Python"
def inner():
print(language)
inner()
outer()Output:
PythonThe inner function does not define language locally, so Python searches the enclosing scope and finds "Python" before reaching the global value "Java".
def display_items(items):
return len(items)
print(display_items(["Pen", "Book", "Bag"]))Output:
3The name len is found in Python's built-in namespace because no closer binding for that name is defined in the function or surrounding scopes.
| Feature | Local | Global | Nonlocal |
|---|---|---|---|
| Where it applies | Current function | Current module | Nearest enclosing function scope |
| Typical declaration | No special keyword | global when rebinding a global name inside a function |
nonlocal when rebinding an enclosing name |
| Can be read in a nested function? | Only if it is in that function's lookup chain | Yes, if not shadowed | Yes, when in an enclosing function scope |
| Can be reassigned? | Yes, locally | Yes, with global inside a function |
Yes, with nonlocal inside a nested function |
| Common use | Temporary calculations | Module-wide configuration or shared state | State retained by nested functions |
Global variables are sometimes useful for module-level configuration values that functions need to read.
APP_NAME = "Student Portal"
MAX_LOGIN_ATTEMPTS = 3
def display_configuration():
print("Application:", APP_NAME)
print("Maximum attempts:", MAX_LOGIN_ATTEMPTS)
display_configuration()Output:
Application: Student Portal
Maximum attempts: 3Configuration values that should remain unchanged by ordinary program operations are often written in uppercase by convention. Python does not enforce constants merely because their names are uppercase.
Local variables are suitable for intermediate values that are only needed while a function performs a calculation.
def calculate_bill(price, quantity, discount_percent):
subtotal = price * quantity
discount = subtotal * discount_percent / 100
final_amount = subtotal - discount
return final_amount
bill = calculate_bill(500, 4, 10)
print("Final bill:", bill)Output:
Final bill: 1800.0The variables subtotal, discount, and final_amount are local. Keeping them inside the function avoids unnecessary changes to module-level state.
A nested function can use nonlocal to maintain a score across several calls.
def create_score_tracker():
score = 0
def update_score(points):
nonlocal score
score += points
return score
return update_score
add_points = create_score_tracker()
print(add_points(10))
print(add_points(15))
print(add_points(5))Output:
10
25
30The variable score belongs to the enclosing function. The nested function updates it and retains the state between calls.
A closure can keep a cart's state private while providing functions to update and inspect it.
def create_cart():
items = []
def add_item(item):
items.append(item)
def get_items():
return items.copy()
def get_total():
return sum(item["price"] for item in items)
return add_item, get_items, get_total
add_item, get_items, get_total = create_cart()
add_item({"name": "Book", "price": 250})
add_item({"name": "Pen", "price": 30})
print(get_items())
print("Total:", get_total())Output:
[{'name': 'Book', 'price': 250}, {'name': 'Pen', 'price': 30}]
Total: 280The nested functions access the enclosing items list. In this example, list mutation is sufficient, so no nonlocal declaration is required. Returning a copy from get_items() prevents callers from directly modifying the internal list through that returned list.
| Error or problem | Cause | Solution |
|---|---|---|
NameError |
A name is not available in the current lookup chain. | Define the name in an appropriate scope or pass it as a parameter. |
UnboundLocalError |
A local variable is read before it has been assigned. | Initialize the local variable first or use the correct scope declaration. |
| Unexpected global value | A local variable shadows a global variable. | Use clearer variable names and check where each name is assigned. |
| Global variable not updated | A function creates a local binding instead of rebinding the global one. | Use global when global reassignment is truly needed. |
| Enclosing variable not updated | A nested function creates a local binding instead of modifying the enclosing one. | Use nonlocal when updating an enclosing function variable. |
| Invalid nonlocal declaration | No suitable binding exists in an enclosing function scope. | Ensure the variable is defined in an enclosing function. |
| Unexpected shared state | Several functions depend on mutable global data. | Prefer parameters, return values, or a well-defined state-management design. |
global only when a function genuinely needs to rebind a module-level name.nonlocal for appropriate nested-function state, such as a closure counter.list, str, or sum for your own variables because they shadow built-ins.Create a function called display_age() with a local variable named age. Print the age inside the function and observe what happens if you try to access it outside.
Create a global variable named company_name. Write a function that displays it without modifying it.
Create a global counter initialized to zero. Write a function that increments it each time the function is called.
Create an outer function with a variable called language. Define an inner function that reads and prints that variable.
Create a nested function that maintains a running total. Use nonlocal to update the total on each call.
Define a variable with the same name in global, enclosing, and local scopes. Print the name from the inner function and explain which value Python selects.
Rewrite a function that updates a global balance so that it accepts the current balance and deposit amount as parameters and returns the updated balance instead.
Objective: Create a simple account manager that demonstrates local variables, global configuration, parameters, and return values.
CURRENCY = "INR"
def deposit(balance, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
return balance + amount
def withdraw(balance, amount):
if amount <= 0:
raise ValueError("Withdrawal must be positive")
if amount > balance:
raise ValueError("Insufficient balance")
return balance - amount
def display_balance(balance):
print(f"Current balance: {CURRENCY} {balance:.2f}")
balance = 5000
balance = deposit(balance, 1500)
display_balance(balance)
balance = withdraw(balance, 2000)
display_balance(balance)Output:
Current balance: INR 6500.00
Current balance: INR 4500.00Project explanation:
CURRENCY is a module-level configuration value read by the display function.balance and amount are parameters used by the deposit and withdrawal functions.Scope is the region in which a name can be accessed. Python resolves names using the LEGB rule.
A local variable is a name defined within a function and normally accessible within that function's local scope.
A global variable is a name defined at the module level. It can be read inside functions unless shadowed by a closer binding.
The global keyword declares that assignments to a name inside a function should rebind the module-level name.
The nonlocal keyword declares that assignments to a name inside a nested function should rebind a name in the nearest suitable enclosing function scope.
Yes. The keyword is unnecessary when the function only reads the global name and does not reassign it.
LEGB stands for Local, Enclosing, Global, and Built-in. It describes the order Python uses to look up names.
Variable shadowing occurs when a name in a nearer scope hides a name with the same spelling in an outer scope.
A closure is a function that retains access to variables from its enclosing scope even after the outer function has returned.
No. nonlocal refers to a binding in an enclosing function scope. Use global for rebinding a module-level name inside a function.
It is an error raised when a local variable is accessed before it has been assigned a value in the current function execution.
Changing global state can create hidden dependencies, complicate testing, and make programs harder to maintain.
Mutating an existing list, such as calling append(), does not require global. Rebinding the global name to a different list does.
The local binding takes precedence inside that function, while the global binding remains unchanged unless explicitly rebound.
global targets a module-level binding, while nonlocal targets a binding in an enclosing function scope.
global keyword is used to rebind a module-level name inside a function.nonlocal keyword allows a nested function to rebind an enclosing function's variable.Understanding local, global, and nonlocal scope is essential for writing clear and reliable Python programs. Local scope keeps temporary variables inside functions, global scope makes module-level names available across a module, and nonlocal scope enables nested functions to update variables belonging to enclosing functions.
The LEGB rule explains how Python finds names. By using local variables by default, limiting global state, and applying global and nonlocal only when appropriate, you can create programs that are easier to understand, debug, test, and maintain.
Continue learning: Explore the Python Training Course, register for a course demo, or visit the JustAcademy website for more learning resources.
